home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / 3DTOSHI2.ZIP / mpg3d / source / G3dobj.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-22  |  11.5 KB  |  384 lines
  1.  
  2. // g3dobj.cpp
  3. //
  4. // Copyright (c) 1996 by Toshiaki Tsuji, all rights reserved.
  5.  
  6. #include "stdgfx.h"
  7. #include "g3dobj.h"
  8.  
  9. G3DOBJECT::G3DOBJECT ()
  10.   {
  11.     SubObjectList = new LINKEDLIST<G3DOBJECT*> ();
  12.     FLPLocalPosition.x = (float)0;
  13.     FLPLocalPosition.y = (float)0;
  14.     FLPLocalPosition.z = (float)0;
  15.     FLPAngle.x = (float)0;
  16.     FLPAngle.y = (float)0;
  17.     FLPAngle.z = (float)0;
  18.     Type = 0;
  19.     InitMatrix ( LocalMatrix );
  20.     LightSource = NULL;
  21.     Moved = Rotated = TRUE;
  22.     Initialized = FALSE;
  23.     MaxVisibleDistance = (float)64000;
  24.     ScaleFactor = (float)1.0;
  25.   } // End of Constructor for G3DOBJECT
  26.  
  27. G3DOBJECT::~G3DOBJECT ()
  28.   {
  29.     if (SubObjectList!=NULL)
  30.       {
  31.         SubObjectList->ClearAllNode ();  
  32.         delete SubObjectList;
  33.       } // End if      
  34.     SubObjectList = NULL;    
  35.   } // End of Destructor for G3DOBJECT
  36.  
  37. VOID G3DOBJECT::SetName ( STRING NewName )
  38.   {
  39.     strcpy ( Name, NewName );  
  40.   } // End of SetName for G3DOBJECT
  41.  
  42. G3DOBJECT* G3DOBJECT::FindObjectByName ( STRING SearchName )
  43.   {
  44.     if (strcmp ( SearchName, Name )==0)
  45.       return this;
  46.       
  47.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  48.     ObjectNode = SubObjectList->GetHead ();
  49.     G3DOBJECT* Object;
  50.  
  51.     while (ObjectNode!=NULL)
  52.       {
  53.         Object = ObjectNode->Data->FindObjectByName ( SearchName );
  54.         if (Object!=NULL)
  55.           return Object;
  56.         ObjectNode = ObjectNode->NextObject;
  57.       } // End while
  58.     return NULL;      
  59.   } // End of FindObjectByName for G3DOBJECT
  60.  
  61. G3DOBJECT* G3DOBJECT::FindObjectByID ( LONG SearchID )
  62.   {
  63.     if (ID==SearchID)
  64.       return this;
  65.       
  66.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  67.     ObjectNode = SubObjectList->GetHead ();
  68.     G3DOBJECT* Object;
  69.  
  70.     while (ObjectNode!=NULL)
  71.       {
  72.         Object = ObjectNode->Data->FindObjectByID ( SearchID );
  73.         if (Object!=NULL)
  74.           return Object;
  75.         ObjectNode = ObjectNode->NextObject;
  76.       } // End while
  77.     return NULL;      
  78.   } // End of FindObjectByID for G3DOBJECT
  79.  
  80. VOID G3DOBJECT::SetPosition ( float x, float y, float z )
  81.   {
  82.     FLPLocalPosition.x = x;  
  83.     FLPLocalPosition.y = y;  
  84.     FLPLocalPosition.z = z;  
  85.   } // End of SetPosition for G3DOBJECT
  86.  
  87. VOID G3DOBJECT::SetAngle ( float x, float y, float z )
  88.   {
  89.     FLPAngle.x = x;  
  90.     FLPAngle.y = y;  
  91.     FLPAngle.z = z;  
  92.   } // End of SetPosition for G3DOBJECT
  93.  
  94. VOID G3DOBJECT::SetScaleFactor ( float NewScaleFactor )
  95.   {
  96.     ScaleFactor = NewScaleFactor;  
  97.   } // End of SetScaleFactor for G3DOBJECT
  98.  
  99. VOID G3DOBJECT::SetMaxVisibleDistance ( float Distance )
  100.   {
  101.     MaxVisibleDistance = Distance;  
  102.   } // End of SetMaxVisibleDistance for G3DOBJECT
  103.  
  104. VOID G3DOBJECT::UpdateLocalToWorld ()
  105.   {
  106.     float x,y,z;
  107.     float cx,cy,cz;
  108.     
  109.     x = (float)0;       
  110.     y = (float)0;       
  111.     z = (float)0;       
  112.     cx = FLPLocalCenter.x + x;       
  113.     cy = FLPLocalCenter.y + y;       
  114.     cz = FLPLocalCenter.z + z;
  115.  
  116.     FLPWorldPosition.x = x*ResultMatrix[0][0]+
  117.                           y*ResultMatrix[1][0]+
  118.                            z*ResultMatrix[2][0]+
  119.                               ResultMatrix[3][0];
  120.     FLPWorldPosition.y = x*ResultMatrix[0][1]+
  121.                           y*ResultMatrix[1][1]+
  122.                            z*ResultMatrix[2][1]+
  123.                               ResultMatrix[3][1];
  124.     FLPWorldPosition.z = x*ResultMatrix[0][2]+
  125.                           y*ResultMatrix[1][2]+
  126.                            z*ResultMatrix[2][2]+
  127.                               ResultMatrix[3][2];
  128.  
  129.     FLPWorldCenter.x  = cx*ResultMatrix[0][0]+
  130.                           cy*ResultMatrix[1][0]+
  131.                            cz*ResultMatrix[2][0]+
  132.                                ResultMatrix[3][0];
  133.     FLPWorldCenter.y  = cx*ResultMatrix[0][1]+
  134.                           cy*ResultMatrix[1][1]+
  135.                            cz*ResultMatrix[2][1]+
  136.                                ResultMatrix[3][1];
  137.     FLPWorldCenter.z  = cx*ResultMatrix[0][2]+
  138.                           cy*ResultMatrix[1][2]+
  139.                            cz*ResultMatrix[2][2]+
  140.                                ResultMatrix[3][2];
  141.   } // End of UpdateLocalToWorld for G3DOBJECT
  142.  
  143. VOID G3DOBJECT::TransformLocalToWorld ( G3DMATRIX ParentMatrix )
  144.   {
  145.     MultMatrix ( LocalMatrix, ParentMatrix, ResultMatrix );
  146.     Scale ( ResultMatrix, ScaleFactor );
  147.     Translate ( ResultMatrix, FLPLocalPosition.x, FLPLocalPosition.y, FLPLocalPosition.z );
  148.  
  149.     UpdateLocalToWorld ();
  150.  
  151.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  152.     ObjectNode = SubObjectList->GetHead ();
  153.  
  154.     while (ObjectNode!=NULL)
  155.       {
  156.         ObjectNode->Data->TransformLocalToWorld ( ResultMatrix );
  157.         ObjectNode = ObjectNode->NextObject;  
  158.       } // End while
  159.       
  160.     InitMatrix ( LocalMatrix );  
  161.   } // End of TransformLocalToWorld for G3DOBJECT 
  162.  
  163. VOID G3DOBJECT::UpdateWorldToCamera ( G3DMATRIX CameraMatrix,
  164.                                       CAMERADATA *CameraData )  
  165.   {
  166.     float x,y,z;
  167.     float cx,cy,cz;
  168.     
  169.     x = FLPWorldPosition.x;       
  170.     y = FLPWorldPosition.y;       
  171.     z = FLPWorldPosition.z;       
  172.     cx = FLPWorldCenter.x;       
  173.     cy = FLPWorldCenter.y;       
  174.     cz = FLPWorldCenter.z;
  175.  
  176.     FLPCameraPosition.x = x*CameraMatrix[0][0]+
  177.                            y*CameraMatrix[1][0]+
  178.                             z*CameraMatrix[2][0]+
  179.                                CameraMatrix[3][0];
  180.     FLPCameraPosition.y = x*CameraMatrix[0][1]+
  181.                            y*CameraMatrix[1][1]+
  182.                             z*CameraMatrix[2][1]+
  183.                                CameraMatrix[3][1];
  184.     FLPCameraPosition.z = x*CameraMatrix[0][2]+
  185.                            y*CameraMatrix[1][2]+
  186.                             z*CameraMatrix[2][2]+
  187.                                CameraMatrix[3][2];
  188.  
  189.     FLPCameraCenter.x  = cx*CameraMatrix[0][0]+
  190.                            cy*CameraMatrix[1][0]+
  191.                             cz*CameraMatrix[2][0]+
  192.                                 CameraMatrix[3][0];
  193.     FLPCameraCenter.y  = cx*CameraMatrix[0][1]+
  194.                            cy*CameraMatrix[1][1]+
  195.                             cz*CameraMatrix[2][1]+
  196.                                 CameraMatrix[3][1];
  197.     FLPCameraCenter.z  = cx*CameraMatrix[0][2]+
  198.                            cy*CameraMatrix[1][2]+
  199.                             cz*CameraMatrix[2][2]+
  200.                                 CameraMatrix[3][2];
  201.  
  202.     ClipObject ( CameraData );
  203.   } // End of UpdateWorldToCamera for G3DOBJECT
  204.  
  205. VOID G3DOBJECT::TransformWorldToCamera ( G3DMATRIX CameraMatrix,
  206.                                          CAMERADATA *CameraData )  
  207.   {    
  208.     UpdateWorldToCamera ( CameraMatrix, CameraData );
  209.  
  210.     if (IsObjectVisible())
  211.       {
  212.         LISTOBJECT<G3DOBJECT*> *ObjectNode;
  213.         ObjectNode = SubObjectList->GetHead ();
  214.  
  215.         while (ObjectNode!=NULL)
  216.           {
  217.             ObjectNode->Data->TransformWorldToCamera ( CameraMatrix,
  218.                                                        CameraData );
  219.             ObjectNode = ObjectNode->NextObject;  
  220.           } // End while 
  221.       } // End if
  222.       
  223.     Moved = Rotated = FALSE;
  224.   } // End of TransformWorldToCamera for G3DOBJECT
  225.  
  226. VOID G3DOBJECT::InitLocalMatrix ()
  227.   {
  228.     InitMatrix ( LocalMatrix );  
  229.   } // End of InitLocalMatrix for G3DOBJECT
  230.  
  231. VOID G3DOBJECT::Init () 
  232.   {
  233.     ComputeCenter ();
  234.     
  235.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  236.     ObjectNode = SubObjectList->GetHead ();
  237.  
  238.     while (ObjectNode!=NULL)
  239.       {
  240.         ObjectNode->Data->Init ();
  241.         ObjectNode = ObjectNode->NextObject;  
  242.       } // End while      
  243.   } // End of Init for G3DOBJECT
  244.  
  245. VOID G3DOBJECT::Move ( float xt, float yt, float zt )
  246.   {
  247.     FLPLocalPosition.x += xt;  
  248.     FLPLocalPosition.y += yt;  
  249.     FLPLocalPosition.z += zt;
  250.     G3DMATRIX Matrix;
  251.     InitMatrix ( Matrix );
  252.     TransformLocalToWorld ( Matrix );
  253.     Moved = TRUE;     
  254.   } // End of Move for G3DOBJECT 
  255.  
  256. VOID G3DOBJECT::Rotate ( float xa, float ya, float za )
  257.   {
  258.     FLPAngle.x += xa;  
  259.     FLPAngle.y += ya;  
  260.     FLPAngle.z += za;
  261.     
  262.     RotateXYZ ( LocalMatrix, FLPAngle.x, FLPAngle.y,
  263.                 FLPAngle.z );
  264.     TransformLocalToWorld ( LocalMatrix );
  265.     Rotated = TRUE;
  266.   } // End of Rotate for G3DOBJECT
  267.  
  268. VOID G3DOBJECT::CountShapes ( LONG *Count )
  269.   {
  270.     if (Count)
  271.       {}  
  272.   } // End of CountShapes for G3DOBJECT
  273.  
  274. VOID G3DOBJECT::CountNumShapes ( LONG *Count )
  275.   {
  276.     CountShapes ( Count );
  277.       
  278.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  279.     ObjectNode = SubObjectList->GetHead ();
  280.  
  281.     while (ObjectNode!=NULL)
  282.       {
  283.         ObjectNode->Data->CountNumShapes ( Count );
  284.         ObjectNode = ObjectNode->NextObject;  
  285.       } // End while       
  286.   } // End of CountNumShapes for G3DOBJECT
  287.  
  288. BOOLEAN G3DOBJECT::ClipObject ( CAMERADATA *CameraData )
  289.   {
  290.     float MaxZ,MinZ;
  291.     MaxZ = FLPCameraCenter.z + Radius;
  292.     MinZ = FLPCameraCenter.z - Radius;
  293.  
  294.     Flags &= ~OBJECT_VISIBLE;
  295.  
  296.     if (MaxZ<CameraData->NearClipZ)
  297.       return FALSE;
  298.     if (MinZ>MaxVisibleDistance)
  299.       return FALSE;  
  300.  
  301.     float MinX,MinY,MaxX,MaxY;
  302.  
  303.     MinX = FLPCameraCenter.x - Radius/2;
  304.     MaxX = FLPCameraCenter.x + Radius/2;
  305.     MinY = FLPCameraCenter.y - Radius/2;
  306.     MaxY = FLPCameraCenter.y + Radius/2;
  307.  
  308.     float MinScrX,MaxScrX;
  309.     float MinScrY,MaxScrY;
  310.  
  311.     float Ratio = CameraData->ViewDistance / MaxZ;
  312.     
  313.     MinScrX = MinX*Ratio + CameraData->CenterX;
  314.     MinScrY = -MaxY*Ratio + CameraData->CenterY;
  315.     MaxScrX = MaxX*Ratio + CameraData->CenterX;
  316.     MaxScrY = -MinY*Ratio + CameraData->CenterY;
  317.     
  318.     if (MinScrX>CameraData->ViewPort.x2)
  319.       return FALSE;
  320.     if (MinScrY>CameraData->ViewPort.y2)
  321.       return FALSE;
  322.     if (MaxScrX<CameraData->ViewPort.x1)
  323.       return FALSE;
  324.     if (MaxScrY<CameraData->ViewPort.y1)
  325.       return FALSE;
  326.       
  327.     Flags |= OBJECT_VISIBLE;
  328.     return TRUE;
  329.   } // End of ClipObject for G3DOBJECT
  330.  
  331. VOID G3DOBJECT::ComputeCenter ()
  332.   {
  333.     FLPLocalCenter = FLPLocalPosition;
  334.   } // End of ComputeCenter for G3DOBJECT
  335.  
  336. float G3DOBJECT::ComputeRadius ()
  337.   {
  338.     float Distance;
  339.     float MaxDist;
  340.  
  341.     MaxDist = (float)0;
  342.     
  343.     LISTOBJECT<G3DOBJECT*> *ObjectNode;
  344.     FLPVECTOR3D SubCenter;
  345.     G3DOBJECT *Object;
  346.     ObjectNode = SubObjectList->GetHead ();
  347.  
  348.     while (ObjectNode!=NULL)
  349.       {
  350.         Object = ObjectNode->Data;
  351.         SubCenter = Object->GetLocalCenter ();
  352.         Distance = Object->ComputeRadius ();
  353.         Distance += FLPVectorDistance ( &FLPLocalCenter, &SubCenter );
  354.         if (MaxDist<Distance)
  355.           MaxDist = Distance;
  356.         ObjectNode = ObjectNode->NextObject;  
  357.       } // End while
  358.  
  359.     Radius = MaxDist;  
  360.     return MaxDist;  
  361.   } // End of ComputeRadius for G3DOBJECT
  362.   
  363. VOID G3DOBJECT::CheckCollision ( FLPVECTOR3D StartPt, FLPVECTOR3D EndPt,
  364.                                  COLLIDEDATA* CollideList, LONG *CurNum, LONG MaxNum,
  365.                                  float CollideDist, float Gap )
  366.   {
  367.     if (*CurNum<MaxNum)
  368.       {
  369.         LISTOBJECT<G3DOBJECT*> *ObjectNode;
  370.         G3DOBJECT *Object;
  371.         ObjectNode = SubObjectList->GetHead ();
  372.  
  373.         while (ObjectNode!=NULL)
  374.           {
  375.             Object = ObjectNode->Data;
  376.             Object->CheckCollision ( StartPt, EndPt, CollideList, CurNum, MaxNum,
  377.                                      CollideDist, Gap );
  378.             ObjectNode = ObjectNode->NextObject;  
  379.           } // End while
  380.       } // End if    
  381.   } // End of CheckColiision for G3DOBJECT                                  
  382.  
  383.  
  384.